home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / ast_comp / cpp-kit.lha / c++kit / Parse.H < prev    next >
C/C++ Source or Header  |  1993-04-11  |  3KB  |  163 lines
  1. /* 9th April, 1993 Mayan Moudgill
  2.  */
  3.  
  4. #ifndef mPARSE_H
  5. #define mPARSE_H
  6.  
  7. #include "Scan.H"
  8.  
  9. class Parse;
  10. class NUMBER;
  11. class STRING;
  12. class IDENT;
  13. class TOKEN;
  14. class CHARAC;
  15. class CHOOSE;
  16. class MATCH0;
  17. template <class T> class MATCH1;
  18. template <class S, class T> class MATCH2;
  19. template <class T> MATCH1<T> MATCH(int (*)(Parse&, T&), T&);
  20. template <class S, class T> MATCH2<S, T> MATCH(int (*)(Parse&, S&, T&), S&, T&);
  21.  
  22. class Parse {
  23. private:
  24.    enum {
  25.       And    =  1,
  26.       Fail   =  2,
  27.       Succ   =  3,
  28.    };
  29.  
  30.    Scan *         _scan;
  31.    Scan::Mark     _marks[4096];
  32.    Scan::Mark *   _mark;
  33.    int            _state;
  34.    int            _retn;
  35. public:
  36.               Parse()
  37.       : _state(Fail) {};
  38.                   Parse(char * file);
  39.                   Parse(Scan&);
  40.  
  41.    void       open(char * file);
  42.    void       open(Scan&);
  43.  
  44.    int            line()
  45.       { return _scan->line(); }
  46.              
  47.               operator int()
  48.       { return _state != Fail; }
  49.               operator () ()
  50.       { return _state != Fail? _retn : 0; }
  51.  
  52.    Parse&         operator , ( char);
  53.    Parse&         operator , ( char *);
  54.    Parse&         operator , ( Parse& (*)(Parse&));
  55.  
  56.    Parse&         operator , ( const NUMBER& );
  57.    Parse&         operator , ( const STRING& );
  58.    Parse&         operator , ( const IDENT& );
  59.    Parse&         operator , ( const TOKEN& );
  60.    Parse&         operator , ( const CHARAC& );
  61.    Parse&         operator , ( const CHOOSE& );
  62.  
  63.    friend
  64.    Parse&         OR(Parse &);
  65.    friend
  66.    Parse&         EOFL(Parse &);
  67.  
  68.    Parse&         operator , ( const MATCH0& );
  69.    template <class T> friend
  70.    Parse&         operator , ( Parse&, const MATCH1<T>& );
  71.    template <class S, class T> friend
  72.    Parse&         operator , ( Parse&, const MATCH2<S, T>& );
  73. };
  74.  
  75. class NUMBER {
  76.    friend class Parse;
  77. private:
  78.    Token *   _token;
  79. public:
  80.              NUMBER(Token& token)
  81.       : _token(&token) {};
  82. };
  83.  
  84. class STRING {
  85.    friend class Parse;
  86. private:
  87.    Token *   _token;
  88. public:
  89.              STRING(Token& token)
  90.       : _token(&token) {};
  91. };
  92.  
  93. class IDENT {
  94.    friend class Parse;
  95. private:
  96.    Token *   _token;
  97. public:
  98.              IDENT(Token& token)
  99.       : _token(&token) {};
  100. };
  101.  
  102. class TOKEN {
  103.    friend class Parse;
  104. private:
  105.    Token *   _token;
  106. public:
  107.              TOKEN(Token& token)
  108.       : _token(&token) {};
  109. };
  110.  
  111. class CHARAC {
  112.    friend class Parse;
  113. private:
  114.    Token *   _token;
  115. public:
  116.              CHARAC(Token& token)
  117.       : _token(&token) {};
  118. };
  119.  
  120. class CHOOSE {
  121.    friend class Parse;
  122. private:
  123.    int       _retn;
  124. public:
  125.              CHOOSE(int retn)
  126.       : _retn(retn) {};
  127. };
  128.  
  129. class MATCH0 {
  130.    friend MATCH0 MATCH(int (*)(Parse&));
  131.    friend class Parse;
  132. private:
  133.    int (*_func)(Parse&);
  134.              MATCH0( int (*func)(Parse&) )
  135.       : _func(func) {};
  136. };
  137.  
  138. template <class T> class MATCH1 {
  139.    friend MATCH1<T> MATCH(int (*)(Parse&, T&), T&);
  140.    friend Parse&    operator , ( Parse&, const MATCH1<T>& );
  141. private:
  142.    int (*_func)(Parse&, T&);
  143.    T&        _value;
  144.  
  145.              MATCH1( int (* func)(Parse&, T&), T& value)
  146.       : _func(func), _value(value) {};
  147. };
  148.  
  149.  
  150. template <class S, class T> class MATCH2 {
  151.    friend MATCH2<S, T> MATCH(int (*)(Parse&, T&), S&, T&);
  152.    friend Parse&       operator , ( Parse&, const MATCH2<S, T>& );
  153. private:
  154.    int (*_func)(Parse&, T&);
  155.    S&        _value1;
  156.    T&        _value2;
  157.  
  158.              MATCH2( int (*func)(Parse&, S&, T&), S& value1, T& value2)
  159.       : _func(func), _value1(value1), _value2(value2) {};
  160. };
  161.  
  162. #endif
  163.